package cn.kgm.core.map;

import java.util.Map;
import java.util.concurrent.ConcurrentMap;
import java.util.function.Consumer;

/**
 * @Version 1.8
 * @AUTHOR: ruoyi
 * @Date: 2023-4-21 14:16
 * @Description: cn.kgm.core.map.ChainMap
 */
public class ChainMap<K, V> extends AbstractCustomMap<K, V> {

    public ChainMap() {
        super();
    }

    public ChainMap(ConcurrentMap<K, V> map) {
        super(map);
    }

    public ChainMap(Map.Entry<K, V> entry) {
        this(entry.getKey(), entry.getValue());
    }

    public ChainMap(K key, V value) {
        this();
        put(key, value);
    }

    public ChainMap(ConcurrentMap<K, V> map, K key, V value) {
        this(map);
        put(key, value);
    }

    /**
     * 快速构建
     *
     * @param key   键
     * @param value 值
     * @param <K>   键类型
     * @param <V>   值类型
     * @return FluentMap
     */
    public static <K, V> ChainMap<K, V> of(K key, V value) {
        return new ChainMap<K, V>().set(key, value);
    }


    /**
     * 增加节点
     *
     * @param key   键
     * @param value 值
     * @return {@link ChainMap}
     */
    public ChainMap<K, V> set(K key, V value) {
        return set(true, key, value);
    }


    /**
     * 增加节点
     *
     * @param condition 执行条件
     * @param key       键
     * @param value     值
     * @return {@link ChainMap}
     */
    public ChainMap<K, V> set(boolean condition, K key, V value) {
        if (condition) {
            put(key, value);
        }
        return this;
    }

    /**
     * 执行自定义逻辑
     *
     * @param function 自定义逻辑
     * @return FluentMap
     */
    public ChainMap<K, V> func(Consumer<ChainMap<K, V>> function) {
        return func(true, function);
    }

    /**
     * 执行自定义逻辑
     *
     * @param condition 执行条件
     * @param function  自定义逻辑
     * @return FluentMap
     */
    public ChainMap<K, V> func(boolean condition, Consumer<ChainMap<K, V>> function) {
        if (condition && function != null) {
            function.accept(this);
        }
        return this;
    }
}
